const { app, BrowserWindow, dialog } = require('electron');
const path = require('path');
const fs = require('fs');
// 避免重复创建窗口
let mainWindow;
let isConfirmingExit = false; // 防止重复触发确认对话框
const createSplash = () => {
  const splash = new BrowserWindow({
    width: 420,
    height: 280,
    useContentSize: true,
    frame: false,
    alwaysOnTop: true,
    resizable: false,
    transparent: false,
    show: false,
    backgroundColor: '#111111',
    webPreferences: { backgroundThrottling: false }
  })
  const html = `
  <html>
    <head>
      <meta charset='utf-8' />
      <title>Loading</title>
      <style>
        html,body{height:100%;margin:0;background:#111;color:#fff;font-family:system-ui,Segoe UI,Roboto,Helvetica,Arial}
        .wrap{height:100%;display:flex;align-items:center;justify-content:center;flex-direction:column}
        .spinner{width:56px;height:56px;border:6px solid rgba(255,255,255,.2);border-top-color:#4ea1ff;border-radius:50%;animation:spin 1s linear infinite}
        @keyframes spin{to{transform:rotate(360deg)}}
        .tip{margin-top:12px;opacity:.8}
      </style>
    </head>
    <body>
      <div class='wrap'>
        <div class='spinner'></div>
        <div class='tip'>正在加载，请稍候…</div>
      </div>
    </body>
  </html>`
  splash.loadURL('data:text/html;charset=utf-8,' + encodeURIComponent(html))
  splash.once('ready-to-show', () => splash.show())
  return splash
}
function getConfigPath() {
  let configPath;

  if (app.isPackaged) {
    // 打包后，将配置文件放在应用安装目录，用户可以修改
    const exeDir = path.dirname(app.getPath('exe'));
    configPath = path.join(exeDir, 'config.json');

    // 如果用户目录中没有配置文件，从资源目录复制默认配置
    if (!fs.existsSync(configPath)) {
      const defaultConfigPath = path.join(process.resourcesPath, 'config.json');
      if (fs.existsSync(defaultConfigPath)) {
        try {
          fs.copyFileSync(defaultConfigPath, configPath);
          console.log('已复制默认配置文件到:', configPath);
        } catch (error) {
          console.error('复制配置文件失败:', error);
          // 如果复制失败，直接使用资源目录中的配置文件
          configPath = defaultConfigPath;
        }
      }
    }
  } else {
    // 开发环境，config.json 在项目根目录
    configPath = path.join(__dirname, 'config.json');
  }

  console.log('configPath', configPath);
  console.log('config exists:', fs.existsSync(configPath));

  return configPath;
}
// 读取配置文件
function readConfig() {
  const configPath = getConfigPath();
  try {
    const configData = fs.readFileSync(configPath, 'utf-8');
    return JSON.parse(configData);
  } catch (error) {
    console.error('读取配置文件失败:', error);
    // 返回默认配置
    return { url: 'https://www.baidu.com' };
  }
}

// 监听配置文件变化，自动重载URL
function watchConfig() {
  // 使用与getConfigPath相同的逻辑获取配置文件路径
  const configPath = getConfigPath();

  console.log('监听配置文件:', configPath);

  // 只在配置文件存在时才监听
  if (!fs.existsSync(configPath)) {
    console.warn('配置文件不存在，跳过监听:', configPath);
    return;
  }

  let debounceTimer = null;
  let lastConfig = JSON.stringify(readConfig()); // 记录上次的配置内容

  try {
    // 监听文件变化（change事件）
    const watcher = fs.watch(configPath, (eventType) => {
      console.log('配置文件变化事件:', eventType, configPath);

      if (eventType === 'change') { // 仅当文件内容修改时触发
        // 清除之前的定时器
        if (debounceTimer) {
          clearTimeout(debounceTimer);
        }

        // 设置防抖定时器，500ms 后执行
        debounceTimer = setTimeout(() => {
          try {
            const newConfig = readConfig();
            const newConfigStr = JSON.stringify(newConfig);
            console.log('newConfig', newConfig)
            console.log('配置变化检查:', { lastConfig, newConfigStr });

            // 只有当配置真正发生变化时才更新
            if (newConfigStr !== lastConfig) {
              lastConfig = newConfigStr;
              console.log('配置已更新，重新加载URL:', newConfig.url);

              // 验证URL格式
              try {
                new URL(newConfig.url);
              } catch (urlError) {
                dialog.showErrorBox('URL格式错误', `无效的URL格式: ${newConfig.url}`);
                return;
              }

              // 监听页面加载事件
              const handleLoadSuccess = () => {
                dialog.showMessageBox(mainWindow, {
                  type: 'info',
                  title: '配置更新',
                  message: '链接已自动更新'
                });
                mainWindow.webContents.removeListener('did-finish-load', handleLoadSuccess);
                mainWindow.webContents.removeListener('did-fail-load', handleLoadFail);
              };

              const handleLoadFail = (event, errorCode, errorDescription, validatedURL) => {
                console.error('页面加载失败:', errorCode, errorDescription, validatedURL);

                // 显示错误提示，但不阻塞用户操作
                dialog.showMessageBox(mainWindow, {
                  type: 'error',
                  title: '页面加载失败',
                  message: `无法加载页面: ${validatedURL}`,
                  detail: `错误: ${errorDescription}\n\n请检查URL是否正确或网络连接是否正常。`,
                  buttons: ['确定']
                });

                // 恢复到上一个有效的配置
                lastConfig = JSON.stringify(readConfig());

                mainWindow.webContents.removeListener('did-finish-load', handleLoadSuccess);
                mainWindow.webContents.removeListener('did-fail-load', handleLoadFail);
              };

              mainWindow.webContents.once('did-finish-load', handleLoadSuccess);
              mainWindow.webContents.once('did-fail-load', handleLoadFail);

              // 加载新URL
              mainWindow.loadURL(newConfig.url).catch(loadError => {
                console.error('loadURL失败:', loadError);
                dialog.showErrorBox('加载失败', `无法加载URL: ${newConfig.url}\n${loadError.message}`);
              });
            }
          } catch (error) {
            console.error('处理配置更新失败:', error);
            dialog.showErrorBox('配置错误', `更新URL失败：${error.message}`);
          }
        }, 500);
      }
    });

    console.log('配置文件监听已启动');

    // 当应用退出时清理监听器
    app.on('before-quit', () => {
      if (watcher) {
        watcher.close();
      }
    });

  } catch (error) {
    console.error('启动配置文件监听失败:', error);
  }
}


function createWindow() {
  const splash = createSplash()
  // 创建应用窗口
  mainWindow = new BrowserWindow({
    width: 1200,
    height: 800,
    fullscreenable: false, // 允许全屏
    autoHideMenuBar: true, // 自动隐藏菜单栏
    frame: true, // 保留窗口框架（如果需要完全无边框，设置为 false）
    show: false, // 先不显示窗口，等页面加载完成后再显示（避免白屏）
    // backgroundColor: '#efefef', // 设置背景色为深色，避免白屏闪烁（可根据你的网站主题调整）
    icon: path.join(__dirname, 'build/icons/win/icon.ico'), //应用顶部栏显示的logo
    webPreferences: {
      contextIsolation: true, // 开启上下文隔离（安全推荐）
      nodeIntegration: false, // 禁用Node集成（安全推荐）
      preload: path.join(__dirname, 'preload.js') // 预加载脚本（可选）
    }
  });
  const config = readConfig();
  console.log('config====', config);
  const url = config.url || 'https://www.baidu.com';
  console.log('url======', url)
  mainWindow.loadURL(url);
  // 打开开发者工具（调试用，打包时可删除）
  mainWindow.webContents.openDevTools();
  // 隐藏菜单栏（确保工具栏不显示）
  mainWindow.setMenuBarVisibility(false);
  // 监听窗口准备就绪事件，页面加载完成后再显示窗口（避免白屏）
  mainWindow.once('ready-to-show', () => {
    if (mainWindow) {
      if (!splash.isDestroyed()) splash.close()
      mainWindow.show();
      mainWindow.setFullScreen(true); // 确保全屏显示
    }
  });

  // 监听页面加载完成事件（备用方案）
  mainWindow.webContents.once('did-finish-load', () => {
    // 如果窗口还没有显示，则显示它
    if (mainWindow && !mainWindow.isVisible()) {
      if (!splash.isDestroyed()) splash.close()
      mainWindow.show();
      mainWindow.setFullScreen(true); // 确保全屏显示
    }
  });

  // 拦截新窗口创建（如点击链接或按钮打开的新窗口）
  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
    // 创建子窗口并应用相同的优化
    createChildWindow(url);
    return { action: 'deny' }; // 阻止默认行为，使用我们自定义的窗口
  });

  // 监听键盘输入事件，捕获 Esc 键
  mainWindow.webContents.on('before-input-event', (event, input) => {
    if (input.key === 'Escape' && !isConfirmingExit) {
      event.preventDefault(); // 阻止默认行为
      showExitConfirmation();
    }
  });

  // 窗口关闭事件
  mainWindow.on('closed', () => {
    mainWindow = null;
  });
}

// 创建子窗口（优化白屏问题）
function createChildWindow(url) {
  // 创建子窗口
  const childWindow = new BrowserWindow({
    width: 1200,
    height: 800,
    fullscreenable: true,
    autoHideMenuBar: true,
    frame: true,
    show: false, // 先不显示窗口，等页面加载完成后再显示（避免白屏）
    icon: path.join(__dirname, 'build/icons/win/icon.ico'),
    parent: mainWindow, // 设置父窗口
    modal: false, // 非模态窗口
    webPreferences: {
      contextIsolation: true,
      nodeIntegration: false,
      preload: path.join(__dirname, 'preload.js')
    }
  });

  // 隐藏菜单栏
  childWindow.setMenuBarVisibility(false);

  // 监听窗口准备就绪事件，页面加载完成后再显示窗口（避免白屏）
  childWindow.once('ready-to-show', () => {
    if (childWindow && !childWindow.isDestroyed()) {
      childWindow.show();
      // 可以根据需要设置子窗口是否为全屏
      // childWindow.setFullScreen(true);
    }
  });

  // 监听页面加载完成事件（备用方案）
  childWindow.webContents.once('did-finish-load', () => {
    // 如果窗口还没有显示，则显示它
    if (childWindow && !childWindow.isDestroyed() && !childWindow.isVisible()) {
      childWindow.show();
    }
  });

  // 监听页面加载失败事件
  childWindow.webContents.on('did-fail-load', (event, errorCode, errorDescription) => {
    console.error('子窗口加载失败:', errorCode, errorDescription);
    // 即使加载失败，也显示窗口（避免一直不显示）
    if (childWindow && !childWindow.isDestroyed() && !childWindow.isVisible()) {
      childWindow.show();
    }
  });

  // 加载URL（放在事件监听之后，确保事件监听器已设置）
  childWindow.loadURL(url).catch(err => {
    console.error('加载URL失败:', err);
    // 如果加载失败，仍然显示窗口
    if (childWindow && !childWindow.isDestroyed() && !childWindow.isVisible()) {
      childWindow.show();
    }
  });

  // 子窗口关闭事件
  childWindow.on('closed', () => {
    // 子窗口关闭后，如果需要可以在这里处理
  });

  // 子窗口也支持 Esc 键退出（可选）
  childWindow.webContents.on('before-input-event', (event, input) => {
    if (input.key === 'Escape') {
      // 子窗口按 Esc 直接关闭，不显示确认对话框
      childWindow.close();
    }
  });

  return childWindow;
}

// 显示退出确认对话框
async function showExitConfirmation() {
  if (!mainWindow || isConfirmingExit) return;

  isConfirmingExit = true; // 设置标志，防止重复触发

  try {
    const { response } = await dialog.showMessageBox(mainWindow, {
      type: 'question',
      buttons: ['确认', '取消'],
      defaultId: 1, // 默认选中"取消"
      cancelId: 1, // 按 ESC 或点击取消时返回 1
      title: '退出确认',
      message: '确定要退出程序吗？',
      detail: '点击"确认"将关闭应用程序。'
    });

    // 点击了确认
    if (response === 0) {
      app.quit();
    }
  } catch (error) {
    console.error('显示确认对话框时出错:', error);
  } finally {
    setTimeout(() => {
      isConfirmingExit = false;
    }, 300); // 延迟一点时间，避免快速连续按键
  }
}

// 应用就绪后创建窗口,调用监听
app.whenReady().then(() => {
  createWindow();
  watchConfig(); // 启动配置监听
});

// 关闭所有窗口时退出（Mac除外）
app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') app.quit();
});

// Mac点击 dock 图标时重建窗口
app.on('activate', () => {
  if (BrowserWindow.getAllWindows().length === 0) createWindow();
});